{
    "cells": [
        {
            "cell_type": "markdown",
            "metadata": {
                "id": "1Gyzk-79jakA"
            },
            "source": [
                "To train this agent, click _Runtime_ and press _Run all_. Make sure you've enabled a free Tesla T4 GPU!\n",
                "\n",
                "<div class=\"align-center\">\n",
                "<a href=\"https://github.com/openpipe/art\"><img src=\"https://github.com/openpipe/art/raw/main/assets/ART_pill.png\" height=\"50\"></a>\n",
                "<a href=\"https://discord.com/invite/dnseNZuQ\"><img src=\"https://github.com/openpipe/art/raw/main/assets/Discord_pill.png\" height=\"50\"></a>\n",
                "<a href=\"https://openpipe.ai/blog/art-e-mail-agent\"><img src=\"https://github.com/openpipe/art/raw/main/assets/ART_E_pill.png\" height=\"50\"></a>\n",
                "\n",
                "Questions? Join the Discord and ask away! For feature requests or to leave a star, visit our [GitHub](https://github.com/openpipe/art).\n",
                "\n",
                "</div>\n",
                "\n",
                "<a href=\"https://art.openpipe.ai/\"><img src=\"https://github.com/openpipe/art/raw/main/assets/Header_separator.png\" height=\"5\"></a>\n",
                "\n",
                "This notebook shows how to train a Qwen 2.5 3B model to play Codenames. It will demonstrate how to set up a multi-turn agent, how to train it, and how to evaluate it.\n",
                "\n",
                "Completions will be logged to OpenPipe, and metrics will be logged to Weights & Biases.\n",
                "\n",
                "You will learn how to construct an [agentic environment](#Environment), how to define a [rollout](#Rollout), and how to run a [training loop](#Loop).\n"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "id": "a0MXGfxPjakD"
            },
            "source": [
                "### Installation\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "id": "xA5ADGKPjakD"
            },
            "outputs": [],
            "source": [
                "%%capture\n",
                "!uv pip install openpipe-art==0.3.11.post2 \"gql<4\" --prerelease allow --no-cache-dir"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "id": "-UAxXzqEjakC"
            },
            "source": [
                "### Environment Variables\n",
                "\n",
                "Later on in the notebook, we'll be creating a model that can automatically logs metrics to Weights & Biases. In order to do so, you'll need to provide your Weights & Biases API key as an environment variable.\n",
                "\n",
                "You can also optionally initiate an OpenPipe client to report completions to a [dashboard](https://app.openpipe.ai) to get a feel for what the completions your model is generating look like, and how they change over time. Logging to OpenPipe is free, but is not required for training!\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "id": "d_8E8Yj3jakC"
            },
            "outputs": [],
            "source": [
                "import os\n",
                "\n",
                "# Optional - We need an OPENAI_API_KEY to run validation. This is optional, and we will skip validation if not provided\n",
                "OPENAI_API_KEY = \"\"\n",
                "if OPENAI_API_KEY:\n",
                "    os.environ[\"OPENAI_API_KEY\"] = OPENAI_API_KEY\n",
                "\n",
                "# Optional\n",
                "WANDB_API_KEY = \"\"\n",
                "if WANDB_API_KEY:\n",
                "    os.environ[\"WANDB_API_KEY\"] = WANDB_API_KEY\n",
                "\n",
                "# Optional\n",
                "OPENPIPE_API_KEY = \"\"\n",
                "if OPENPIPE_API_KEY:\n",
                "    os.environ[\"OPENPIPE_API_KEY\"] = OPENPIPE_API_KEY"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "id": "C5n8N1uSjakD"
            },
            "source": [
                "# Agentic Environment\n",
                "\n",
                "<a name=\"Environment\"></a>\n",
                "\n",
                "ART allows your agent to learn by interacting with its environment. In this example, we'll create an environment in which the agent can play Codenames.\n",
                "\n",
                "Feel free to read as much or as little of this section's code as you'd like. The important thing to understand is that we're defining the rules of this agent's environment. In many cases, this will already be defined by the task you're trying to solve, but if you need to define a custom environment, this is how you do it.\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "colab": {
                    "base_uri": "https://localhost:8080/"
                },
                "id": "K9h-g67egOpy",
                "outputId": "f6489f2d-a795-4dc5-82ba-24a0cda6dbea"
            },
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n",
                        "                                 Dload  Upload   Total   Spent    Left  Speed\n",
                        "100  2481  100  2481    0     0   6941      0 --:--:-- --:--:-- --:--:--  6949\n",
                        "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n",
                        "                                 Dload  Upload   Total   Spent    Left  Speed\n",
                        "100 4749k  100 4749k    0     0  5151k      0 --:--:-- --:--:-- --:--:-- 5150k\n"
                    ]
                }
            ],
            "source": [
                "# Download the 400 original codenames words and a dictionary to ensure that the clue is not outside of this dictionary\n",
                "import requests\n",
                "\n",
                "codenames_words_path = \"https://raw.githubusercontent.com/OpenPipe/ART/refs/heads/main/examples/codenames/codenames_words.json\"\n",
                "dictionary_path = \"https://raw.githubusercontent.com/OpenPipe/ART/refs/heads/main/examples/codenames/dictionary.json\"\n",
                "CODENAMES_WORDS = requests.get(codenames_words_path).json()\n",
                "DICTIONARY = requests.get(dictionary_path).json()"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "id": "we0PhGpVoGmR",
                "outputId": "fc39772e-7f84-4dc4-8915-ff1125636b2f"
            },
            "outputs": [],
            "source": [
                "# Basic imports to get us running\n",
                "# ───────────────────────────────  Imports  ────────────────────────────────\n",
                "import asyncio\n",
                "import copy\n",
                "import random\n",
                "import re\n",
                "import time\n",
                "import uuid\n",
                "from typing import Dict, List, Tuple\n",
                "\n",
                "from tqdm.asyncio import tqdm_asyncio\n",
                "\n",
                "import art\n",
                "from openpipe.client import AsyncOpenPipe"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "id": "jSlnMfuvoK0O"
            },
            "outputs": [],
            "source": [
                "# ───────────────────────────────  Config  ──────────────────────────────\n",
                "NUM_STEPS = 140\n",
                "NUM_GAMES_PER_STEP = 10\n",
                "NUM_ROLLOUTS_PER_GAME = 20\n",
                "# reduce all three above to 5 to run the example quickly\n",
                "\n",
                "MODEL_NAME = \"codenames_model_op_3\"\n",
                "BASE_MODEL_NAME = \"Qwen/Qwen2.5-3B-Instruct\"\n",
                "VAL_BENCHMARK_MODEL = \"gpt-4.1-nano\"\n",
                "NUM_VALIDATION_GAMES = 50\n",
                "LEARNING_RATE = 5e-6\n",
                "BETA = 0.0\n",
                "DEBUG = False\n",
                "\n",
                "# — reward constants —\n",
                "# The following is the weightage for different kinds of outcomes from a game, to determine the reward\n",
                "MARGIN_REWARD_DICT = {\n",
                "    \"turn_limit\": -100,  # if the game reaches the turn limit for some reason, the team gets this penalty\n",
                "    \"error\": -100,  # if the game ends in an error, the team player that caused the error gets this penalty (e.g. spymaster gets this penalty if the clue is invalid)\n",
                "    \"assassin\": -30,  # if the team guesses the assassin, they get this penalty (both spymaster and operative get the penalty, since it could be an issue with the spymaster's clue or the operative's guess)\n",
                "    \"num_words_multiplier\": 10,  # the team gets this reward for each word they guess (fraction of words they guess correctly * num_words_multiplier)\n",
                "    \"margin_multiplier\": 1,  # the team gets this reward for however many words they defeat the other team by (difference in the number of words * margin_multiplier) (the losing team gets the negative of this)\n",
                "}"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "id": "_YTBUEFepm_J"
            },
            "outputs": [],
            "source": [
                "# ────────────────────────  1. Utility helpers  ────────────────────────────\n",
                "async def call_llm(\n",
                "    model: art.Model,\n",
                "    messages: List[Dict[str, str]],\n",
                "    temperature: float = 0.7,\n",
                "    max_tokens: int = 500,\n",
                "    num_retries: int = 3,\n",
                "):\n",
                "    \"\"\"\n",
                "    Minimal, retry‑aware wrapper around `chat.completions.create`.\n",
                "    \"\"\"\n",
                "    for attempt in range(num_retries):\n",
                "        try:\n",
                "            client = model.openai_client()\n",
                "            resp = await client.chat.completions.create(\n",
                "                model=model.name,\n",
                "                messages=messages,\n",
                "                temperature=temperature,\n",
                "                max_tokens=max_tokens,\n",
                "                logprobs=True,\n",
                "                store=False,\n",
                "            )\n",
                "            if not resp:\n",
                "                raise RuntimeError(\"empty response\")\n",
                "            return resp\n",
                "        except Exception as e:\n",
                "            print(f\"LLM error ({attempt + 1}/{num_retries}): {e}\")\n",
                "            await asyncio.sleep(1)\n",
                "    raise RuntimeError(\"LLM call failed after retries\")\n",
                "\n",
                "\n",
                "# ───────────────────────  2. Core game classes  ───────────────────────────\n",
                "class Card:\n",
                "    \"\"\"\n",
                "    One word on the Codenames board.\n",
                "    \"\"\"\n",
                "\n",
                "    def __init__(self, word: str, color: str):\n",
                "        self.word = word\n",
                "        self.color = color  # blue | red | neutral | assassin\n",
                "        self.revealed = False\n",
                "\n",
                "    def __repr__(self) -> str:\n",
                "        return f\"{self.word}{'(X)' if self.revealed else ''}:{self.color}\"\n",
                "\n",
                "\n",
                "class GameState:\n",
                "    \"\"\"\n",
                "    Full mutable game state with an event log.\n",
                "    \"\"\"\n",
                "\n",
                "    def __init__(\n",
                "        self,\n",
                "        cards: List[Card],\n",
                "        starting_team: str = \"blue\",\n",
                "        game_id: int = 0,\n",
                "    ):\n",
                "        self.cards = cards\n",
                "        self.current_team = starting_team\n",
                "        self.words_left = {\n",
                "            \"blue\": sum(1 for c in cards if c.color == \"blue\"),\n",
                "            \"red\": sum(1 for c in cards if c.color == \"red\"),\n",
                "        }\n",
                "        self.starting_team = starting_team\n",
                "        self.game_id = game_id\n",
                "        self.turn_count = 0\n",
                "\n",
                "        self.last_event_indices: Dict[str, int] = {\n",
                "            \"blue_spymaster\": -1,\n",
                "            \"blue_operative\": -1,\n",
                "            \"red_spymaster\": -1,\n",
                "            \"red_operative\": -1,\n",
                "            \"game_engine\": -1,\n",
                "        }\n",
                "        self.game_events: List[Dict[str, str]] = []\n",
                "\n",
                "        self.game_ended_in_error: Dict[str, str] | None = None\n",
                "        self.game_ended_in_assassin = False\n",
                "        self.game_ended_in_turn_limit = False\n",
                "\n",
                "        self.all_words = DICTIONARY\n",
                "\n",
                "    # ───────── event log helpers ─────────\n",
                "    def log_event(self, role_key: str, description: str) -> None:\n",
                "        self.game_events.append({role_key: description})\n",
                "        self.last_event_indices[role_key] = len(self.game_events) - 1\n",
                "        if DEBUG:\n",
                "            print(f\"{role_key}: {description}\")\n",
                "\n",
                "    def format_events_for_player(self, role_key: str) -> str:\n",
                "        last_seen = self.last_event_indices.get(role_key, -1)\n",
                "        new_events = self.game_events[last_seen + 1 :]\n",
                "        if not new_events:\n",
                "            return \"\"\n",
                "        lines = [\"--- events since your last turn ---\"]\n",
                "        for ev in new_events:\n",
                "            for rk, desc in ev.items():\n",
                "                lines.append(f\"{rk}: {desc}\")\n",
                "        lines.append(\"----------------------------------\")\n",
                "        return \"\\n\".join(lines)\n",
                "\n",
                "    # ───────── board helpers ─────────\n",
                "    def reveal_card(self, card: Card) -> str | None:\n",
                "        if card.revealed:\n",
                "            return None\n",
                "        card.revealed = True\n",
                "        if card.color in (\"blue\", \"red\"):\n",
                "            self.words_left[card.color] -= 1\n",
                "        return card.color\n",
                "\n",
                "    def get_unrevealed_cards(self) -> List[Card]:\n",
                "        return [c for c in self.cards if not c.revealed]\n",
                "\n",
                "    def get_revealed_cards(self) -> List[Card]:\n",
                "        return [c for c in self.cards if c.revealed]\n",
                "\n",
                "    # ───────── rules / win conditions ─────────\n",
                "    def check_end_game(self) -> Tuple[str | None, str | None]:\n",
                "        # assassin?\n",
                "        if any(c for c in self.cards if c.color == \"assassin\" and c.revealed):\n",
                "            loser = self.current_team\n",
                "            winner = \"red\" if loser == \"blue\" else \"blue\"\n",
                "            self.game_ended_in_assassin = True\n",
                "            return winner, f\"{loser} revealed the assassin\"\n",
                "        # all words guessed?\n",
                "        if self.words_left[\"blue\"] == 0:\n",
                "            return \"blue\", \"Blue found all their words\"\n",
                "        if self.words_left[\"red\"] == 0:\n",
                "            return \"red\", \"Red found all their words\"\n",
                "        return None, None\n",
                "\n",
                "    def switch_turn(self) -> None:\n",
                "        self.current_team = \"red\" if self.current_team == \"blue\" else \"blue\"\n",
                "\n",
                "    def follows_clue_rules(self, clue_word: str) -> bool:\n",
                "        # single token\n",
                "        if len(clue_word.split()) > 1:\n",
                "            return False\n",
                "        # letters / hyphens only\n",
                "        if re.search(r\"[^A-Za-z\\-]\", clue_word):\n",
                "            return False\n",
                "        # cannot be an unrevealed board word\n",
                "        if clue_word.lower() in {c.word.lower() for c in self.get_unrevealed_cards()}:\n",
                "            return False\n",
                "        # must be in dictionary\n",
                "        if clue_word.lower() not in self.all_words:\n",
                "            return False\n",
                "        return True\n",
                "\n",
                "\n",
                "def create_operative_feedback(max_guesses, guesses_taken, guess, color, outcome):\n",
                "    operative_feedback = \"\"\n",
                "    if outcome.startswith(\"correct\"):\n",
                "        operative_feedback = (\n",
                "            f\"Your guess '{guess}' was correct! It belongs to your team ({color}).\"\n",
                "        )\n",
                "        if guesses_taken >= max_guesses:\n",
                "            operative_feedback += f\" Max guesses reached ({max_guesses}), ending turn.\"\n",
                "        else:\n",
                "            operative_feedback += \" Either provide your next guess from the unrevealed cards on the board, or say end_turn.\"\n",
                "    elif outcome == \"neutral\":\n",
                "        operative_feedback = f\"Your guess '{guess}' was neutral. Your turn ends here.\"\n",
                "    elif outcome.startswith(\"other_team\"):\n",
                "        operative_feedback = f\"Your guess '{guess}' belongs to the other team ({color}). Your turn ends here.\"\n",
                "    return operative_feedback\n",
                "\n",
                "\n",
                "# ───────────────────────  3. Game orchestration  ──────────────────────────\n",
                "def create_game(\n",
                "    num_words: int = 25,\n",
                "    blue_count: int = 9,\n",
                "    red_count: int = 8,\n",
                "    assassin_count: int = 1,\n",
                "    neutral_count: int = 7,\n",
                "    starting_team: str = \"blue\",\n",
                "    game_id: int = 0,\n",
                ") -> GameState:\n",
                "    all_codenames_words = CODENAMES_WORDS\n",
                "    random.shuffle(all_codenames_words)\n",
                "    codenames_words = all_codenames_words[:num_words]\n",
                "\n",
                "    colors = (\n",
                "        [\"blue\"] * blue_count\n",
                "        + [\"red\"] * red_count\n",
                "        + [\"assassin\"] * assassin_count\n",
                "        + [\"neutral\"] * neutral_count\n",
                "    )\n",
                "    random.shuffle(colors)\n",
                "\n",
                "    cards = [Card(w, c) for w, c in zip(codenames_words, colors)]\n",
                "    return GameState(cards, starting_team, game_id)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "id": "uFUqDYgwjakD"
            },
            "outputs": [],
            "source": [
                "# ───────────────────────  LLM player classes  ──────────────────────────\n",
                "SPYMASTER_SYSTEM_PROMPT = \"\"\"You are a SPYMASTER in a game of Codenames.\n",
                "You are on a team (blue or red).\n",
                "You see which words belong to blue, red, neutral, and assassin.\n",
                "Your objective:\n",
                "- Give a ONE-WORD CLUE and a NUMBER, to guide your operative to guess your team's words.\n",
                "- Avoid giving a clue that makes your operative guess the assassin word, or else you lose immediately.\n",
                "- If the operative guesses a neutral or enemy word, the word is revealed and your turn ends, but the game continues.\n",
                "Strict format rules:\n",
                "- You must propose exactly one single-word clue\n",
                "- The clue must not be a word on the board\n",
                "- Your output must be in the format: clue_word, number (e.g. \"space, 2\")\n",
                "If you ever deviate from that exact output format, you lose.\n",
                "Please follow these instructions exactly.\"\"\"\n",
                "\n",
                "SPYMASTER_USER_PROMPT = \"\"\"Your turn. You are the {team} spymaster.\n",
                "Here is the current board (from your perspective), showing:\n",
                "  - which words are unrevealed (and their colors),\n",
                "  - which words are revealed (and their colors).\n",
                "You need to give a single-word clue and a number of words you want your operative to guess.\n",
                "\n",
                "{board}\n",
                "\n",
                "Please provide your ONE-WORD clue and a number, in the format: clue_word, number\"\"\"\n",
                "\n",
                "OPERATIVE_SYSTEM_PROMPT = \"\"\"You are an OPERATIVE in a game of Codenames.\n",
                "- Your spymaster gives you a ONE-WORD CLUE and a NUMBER.\n",
                "- You must guess words from the unrevealed board that match that clue.\n",
                "- You propose exactly ONE guess at a time, or say \"end_turn\" to stop guessing.\n",
                "- If you guess an enemy word or neutral word, your turn ends.\n",
                "- If you guess the assassin word, you immediately lose.\n",
                "- The clue's NUMBER is how many words the spymaster believes are related, but you can guess up to NUMBER + 1 (or fewer).\n",
                "Format rules:\n",
                "- Output must be either a single unrevealed word present on the board or \"end_turn\".\n",
                "- If you deviate from that, you lose.\"\"\"\n",
                "\n",
                "OPERATIVE_USER_PROMPT = \"\"\"Your turn. You are the {team} operative.\n",
                "Your spymaster's clue is: \"{clue}\" (number: {num}).\n",
                "Below is the board from your perspective:\n",
                "  - Which words are still unrevealed (without color info),\n",
                "  - Which words are revealed (with color).\n",
                "\n",
                "{board}\n",
                "\n",
                "Remember: Output exactly one guess word or 'end_turn'.\"\"\"\n",
                "\n",
                "\n",
                "class LLMSpymaster:\n",
                "    def __init__(\n",
                "        self,\n",
                "        team: str,\n",
                "        model: art.Model,\n",
                "        temperature: float = 0.7,\n",
                "        max_tokens: int = 20,\n",
                "    ):\n",
                "        self.team = team\n",
                "        self.model = model\n",
                "        self.temperature = temperature\n",
                "        self.max_tokens = max_tokens\n",
                "        self.conversation: List[Dict[str, str]] = [\n",
                "            {\"role\": \"system\", \"content\": SPYMASTER_SYSTEM_PROMPT}\n",
                "        ]\n",
                "        self.conversation_choices: List[dict] = []\n",
                "\n",
                "    def _board_summary(self, game_state):\n",
                "        unrevealed_cards = game_state.get_unrevealed_cards()\n",
                "        revealed_cards = game_state.get_revealed_cards()\n",
                "\n",
                "        lines = []\n",
                "        lines.append(f\"Number of words left for blue: {game_state.words_left['blue']}\")\n",
                "        lines.append(f\"Number of words left for red: {game_state.words_left['red']}\")\n",
                "        lines.append(\"UNREVEALED WORDS (and their colors):\")\n",
                "        # Group cards by color\n",
                "        # Group cards by color and add them in a specific order\n",
                "        for color in [\n",
                "            self.team,\n",
                "            \"red\" if self.team == \"blue\" else \"blue\",\n",
                "            \"neutral\",\n",
                "            \"assassin\",\n",
                "        ]:\n",
                "            for c in [c for c in unrevealed_cards if c.color == color]:\n",
                "                lines.append(f\"  {c.word} => {c.color}\")\n",
                "        lines.append(\"REVEALED WORDS (and their colors):\")\n",
                "        for c in revealed_cards:\n",
                "            lines.append(f\"  {c.word} => {c.color} (revealed)\")\n",
                "\n",
                "        return \"\\n\".join(lines)\n",
                "\n",
                "    def _parse_clue(self, text: str, gs: GameState) -> Tuple[str, int]:\n",
                "        try:\n",
                "            cw, num = (s.strip() for s in text.split(\",\", 1))\n",
                "            num = int(num)\n",
                "        except Exception:\n",
                "            return \"invalid\", -1\n",
                "        if not gs.follows_clue_rules(cw):\n",
                "            return \"invalid\", -1\n",
                "        return cw, num\n",
                "\n",
                "    async def get_clue(self, gs: GameState, game_events: str) -> Tuple[str, int]:\n",
                "        if game_events:\n",
                "            self.conversation.append({\"role\": \"user\", \"content\": game_events})\n",
                "\n",
                "        prompt = SPYMASTER_USER_PROMPT.format(\n",
                "            team=self.team, board=self._board_summary(gs)\n",
                "        )\n",
                "        self.conversation.append({\"role\": \"user\", \"content\": prompt})\n",
                "\n",
                "        resp = await call_llm(\n",
                "            self.model,\n",
                "            self.conversation,\n",
                "            self.temperature,\n",
                "            self.max_tokens,\n",
                "        )\n",
                "        self.conversation_choices.append(resp.choices[0])\n",
                "        text = resp.choices[0].message.content.strip()  # type: ignore\n",
                "        self.conversation.append({\"role\": \"assistant\", \"content\": text})\n",
                "\n",
                "        return self._parse_clue(text, gs)\n",
                "\n",
                "\n",
                "class LLMOperative:\n",
                "    def __init__(\n",
                "        self,\n",
                "        team: str,\n",
                "        model: art.Model,\n",
                "        temperature: float = 0.7,\n",
                "        max_tokens: int = 20,\n",
                "    ):\n",
                "        self.team = team\n",
                "        self.model = model\n",
                "        self.temperature = temperature\n",
                "        self.max_tokens = max_tokens\n",
                "        self.conversation: List[Dict[str, str]] = [\n",
                "            {\"role\": \"system\", \"content\": OPERATIVE_SYSTEM_PROMPT}\n",
                "        ]\n",
                "        self.conversation_choices: List[dict] = []\n",
                "        self.new_turn = True\n",
                "\n",
                "    def _board_summary(self, game_state: GameState):\n",
                "        \"\"\"\n",
                "        Build a summary from the operative's perspective:\n",
                "          - unrevealed words (no color info)\n",
                "          - revealed words (with color)\n",
                "        \"\"\"\n",
                "        unrevealed = game_state.get_unrevealed_cards()\n",
                "        revealed = game_state.get_revealed_cards()\n",
                "\n",
                "        lines = []\n",
                "        lines.append(f\"Number of words left for blue: {game_state.words_left['blue']}\")\n",
                "        lines.append(f\"Number of words left for red: {game_state.words_left['red']}\")\n",
                "        lines.append(\"UNREVEALED WORDS (no color info):\")\n",
                "        for c in unrevealed:\n",
                "            lines.append(f\"  {c.word}\")\n",
                "        lines.append(\"REVEALED WORDS (with color):\")\n",
                "        for c in revealed:\n",
                "            lines.append(f\"  {c.word}:{c.color}\")\n",
                "        return \"\\n\".join(lines)\n",
                "\n",
                "    async def guess_word(\n",
                "        self,\n",
                "        gs: GameState,\n",
                "        clue_word: str,\n",
                "        clue_number: int,\n",
                "        game_events: str,\n",
                "    ) -> str:\n",
                "        if self.new_turn:\n",
                "            self.new_turn = False\n",
                "            if game_events:\n",
                "                self.conversation.append({\"role\": \"user\", \"content\": game_events})\n",
                "            prompt = OPERATIVE_USER_PROMPT.format(\n",
                "                team=self.team,\n",
                "                clue=clue_word,\n",
                "                num=clue_number,\n",
                "                board=self._board_summary(gs),\n",
                "            )\n",
                "            self.conversation.append({\"role\": \"user\", \"content\": prompt})\n",
                "\n",
                "        resp = await call_llm(\n",
                "            self.model,\n",
                "            self.conversation,\n",
                "            self.temperature,\n",
                "            self.max_tokens,\n",
                "        )\n",
                "        self.conversation_choices.append(resp.choices[0])\n",
                "        guess = resp.choices[0].message.content.strip()  # type: ignore\n",
                "        self.conversation.append({\"role\": \"assistant\", \"content\": guess})\n",
                "        return guess\n",
                "\n",
                "    def start_new_turn(self):\n",
                "        self.new_turn = True\n",
                "\n",
                "    def add_guess_outcome(self, outcome: str):\n",
                "        self.conversation.append({\"role\": \"user\", \"content\": outcome})"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "id": "x5zSJt3fwD0l"
            },
            "outputs": [],
            "source": [
                "# ───────────────────────  Gameplay  ──────────────────────────\n",
                "async def run_game(\n",
                "    gs: GameState,\n",
                "    blue_spy: LLMSpymaster,\n",
                "    blue_op: LLMOperative,\n",
                "    red_spy: LLMSpymaster,\n",
                "    red_op: LLMOperative,\n",
                ") -> Tuple[str, str]:\n",
                "    \"\"\"\n",
                "    Main loop – returns (winner, reason)\n",
                "    \"\"\"\n",
                "    while True:\n",
                "        # turn limit\n",
                "        if gs.turn_count >= 50:\n",
                "            gs.game_ended_in_turn_limit = True\n",
                "            return \"No winner\", \"Turn limit reached\"\n",
                "\n",
                "        gs.turn_count += 1\n",
                "\n",
                "        # victory check\n",
                "        winner, reason = gs.check_end_game()\n",
                "        if winner:\n",
                "            gs.log_event(\"game_engine\", f\"GAME OVER: {reason}\")\n",
                "            return winner, reason\n",
                "\n",
                "        # who’s up?\n",
                "        team = gs.current_team\n",
                "        spy = blue_spy if team == \"blue\" else red_spy\n",
                "        op = blue_op if team == \"blue\" else red_op\n",
                "        spy_key = f\"{team}_spymaster\"\n",
                "        op_key = f\"{team}_operative\"\n",
                "\n",
                "        # ── Spymaster turn ──\n",
                "        spy_events = gs.format_events_for_player(spy_key)\n",
                "        clue_word, clue_num = await spy.get_clue(gs, spy_events)\n",
                "\n",
                "        if clue_word == \"invalid\" or clue_num < 0:\n",
                "            other = \"red\" if team == \"blue\" else \"blue\"\n",
                "            reason = f\"{team} gave invalid clue\"\n",
                "            gs.log_event(\"game_engine\", f\"GAME OVER: {other} wins – {reason}\")\n",
                "            gs.game_ended_in_error = {\"team\": team, \"role\": \"spymaster\"}\n",
                "            return other, reason\n",
                "\n",
                "        gs.log_event(spy_key, f\"clue '{clue_word}', {clue_num}\")\n",
                "\n",
                "        # ── Operative guesses ──\n",
                "        max_guesses = clue_num + 1\n",
                "        guesses = 0\n",
                "        op.start_new_turn()\n",
                "\n",
                "        while guesses < max_guesses:\n",
                "            # check win before guess\n",
                "            winner, reason = gs.check_end_game()\n",
                "            if winner:\n",
                "                gs.log_event(\"game_engine\", f\"GAME OVER: {reason}\")\n",
                "                return winner, reason\n",
                "\n",
                "            op_events = gs.format_events_for_player(op_key)\n",
                "            guess = await op.guess_word(gs, clue_word, clue_num, op_events)\n",
                "\n",
                "            if guess.lower() == \"end_turn\":\n",
                "                if guesses == 0:\n",
                "                    other = \"red\" if team == \"blue\" else \"blue\"\n",
                "                    reason = f\"{team} ended turn on the first guess\"\n",
                "                    gs.log_event(\"game_engine\", f\"GAME OVER: {other} wins – {reason}\")\n",
                "                    gs.game_ended_in_error = {\"team\": team, \"role\": \"operative\"}\n",
                "                    return other, reason\n",
                "                gs.log_event(op_key, \"ended turn\")\n",
                "                break\n",
                "\n",
                "            # validate guess\n",
                "            card = next(\n",
                "                (\n",
                "                    c\n",
                "                    for c in gs.get_unrevealed_cards()\n",
                "                    if c.word.lower() == guess.lower()\n",
                "                ),\n",
                "                None,\n",
                "            )\n",
                "            if not card:\n",
                "                other = \"red\" if team == \"blue\" else \"blue\"\n",
                "                reason = f\"{team} operative guessed invalid word '{guess}'\"\n",
                "                gs.log_event(op_key, reason)\n",
                "                gs.log_event(\"game_engine\", f\"GAME OVER: {other} wins – {reason}\")\n",
                "                gs.game_ended_in_error = {\"team\": team, \"role\": \"operative\"}\n",
                "                return other, reason\n",
                "\n",
                "            color = gs.reveal_card(card)\n",
                "            guesses += 1\n",
                "            outcome = (\n",
                "                \"correct\"\n",
                "                if color == team\n",
                "                else \"assassin\"\n",
                "                if color == \"assassin\"\n",
                "                else \"other_team\"\n",
                "                if color in (\"blue\", \"red\")\n",
                "                else \"neutral\"\n",
                "            )\n",
                "            gs.log_event(op_key, f\"guessed '{guess}', outcome: {outcome}\")\n",
                "\n",
                "            # feedback for LLM memory\n",
                "            op_feedback = create_operative_feedback(\n",
                "                max_guesses, guesses, guess, color, outcome\n",
                "            )\n",
                "            op.add_guess_outcome(op_feedback)\n",
                "\n",
                "            # post‑guess win check / turn handling\n",
                "            if outcome == \"correct\":\n",
                "                winner, reason = gs.check_end_game()\n",
                "                if winner or guesses >= max_guesses:\n",
                "                    break\n",
                "                continue  # another guess\n",
                "            elif outcome == \"assassin\":\n",
                "                other = \"red\" if team == \"blue\" else \"blue\"\n",
                "                gs.game_ended_in_assassin = True\n",
                "                return other, f\"{team} revealed the assassin\"\n",
                "            else:\n",
                "                break  # neutral or other team ends turn\n",
                "\n",
                "        gs.switch_turn()"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "id": "VcCZwM3gq9V6"
            },
            "outputs": [],
            "source": [
                "# ────────────────────  5. RL / reward helpers  ────────────────────────────\n",
                "def create_mc(player: LLMSpymaster | LLMOperative) -> List[dict]:\n",
                "    \"\"\"\n",
                "    Merge messages & choices into a single list for art.\n",
                "    \"\"\"\n",
                "    mc = []\n",
                "    choice_i = 0\n",
                "    for msg in player.conversation:\n",
                "        if msg[\"role\"] == \"assistant\":\n",
                "            mc.append(player.conversation_choices[choice_i])\n",
                "            choice_i += 1\n",
                "        else:\n",
                "            mc.append(msg)\n",
                "    return mc\n",
                "\n",
                "\n",
                "def create_margin_reward(\n",
                "    player: LLMSpymaster | LLMOperative,\n",
                "    role_key: str,\n",
                "    gs: GameState,\n",
                "    winning_color: str,\n",
                "    reason: str,\n",
                ") -> float:\n",
                "    num_start_words = 9 if player.team == \"blue\" else 8\n",
                "    reward = 0.0\n",
                "\n",
                "    if gs.game_ended_in_turn_limit:\n",
                "        reward += MARGIN_REWARD_DICT[\"turn_limit\"]\n",
                "        return reward\n",
                "    if (\n",
                "        gs.game_ended_in_error\n",
                "        and role_key\n",
                "        == f\"{gs.game_ended_in_error['team']}_{gs.game_ended_in_error['role']}\"\n",
                "    ):\n",
                "        reward += MARGIN_REWARD_DICT[\"error\"]\n",
                "\n",
                "    if gs.game_ended_in_assassin and player.team != winning_color:\n",
                "        reward += MARGIN_REWARD_DICT[\"assassin\"]\n",
                "\n",
                "    # proportion of own words guessed\n",
                "    reward += (\n",
                "        (num_start_words - gs.words_left[player.team])\n",
                "        / num_start_words\n",
                "        * MARGIN_REWARD_DICT[\"num_words_multiplier\"]\n",
                "    )\n",
                "\n",
                "    # margin\n",
                "    loser = \"red\" if winning_color == \"blue\" else \"blue\"\n",
                "    margin = gs.words_left[loser]\n",
                "    reward += (\n",
                "        margin\n",
                "        * MARGIN_REWARD_DICT[\"margin_multiplier\"]\n",
                "        * (1 if player.team == winning_color else -1)\n",
                "    )\n",
                "    return reward"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "id": "u2v5YiKPwu9b"
            },
            "source": [
                "# Defining a rollout\n",
                "\n",
                "<a name=\"Rollout\"></a>\n",
                "\n",
                "In each training step, we start with NUM_GAMES_PER_STEP different Codenames boards (let's say 10).\n",
                "\n",
                "NUM_GAMES_PER_STEP = 10\n",
                "\n",
                "For every board, the model plays 20 complete self‑play games (rollouts).\n",
                "\n",
                "NUM_ROLLOUTS_PER_GAME = 20\n",
                "\n",
                "Each rollout produces four separate records of experience—one for every role in the game—so a single board yields 80 trajectories in total.\n",
                "\n",
                "trajectories_per_rollout = 4 (one each for red spymaster, red operative, blue spymaster, blue operative)\n",
                "\n",
                "trajectories_per_board = NUM_ROLLOUTS_PER_GAME _ trajectories_per_rollout = 20 _ 4 = 80\n",
                "\n",
                "All trajectories from the same board+color+role are grouped together into a trajectory group.\n",
                "\n",
                "trajectory_groups_per_board = trajectories_per_board / NUM_ROLLOUTS_PER_GAME = 80 / 20 = 4\n",
                "\n",
                "Across the NUM_GAMES_PER_STEP (10) boards, this gives us NUM_GAMES_PER_STEP _ trajectory_groups_per_board = 10 _ 4 = 40 trajectory groups that ART uses for training in that step.\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "id": "mevAhbxQwuR1"
            },
            "outputs": [],
            "source": [
                "# ───────────────────────  6. Rollout logic  ───────────────────────────────\n",
                "async def run_single_rollout(\n",
                "    game_state: GameState,\n",
                "    blue_model: art.Model,\n",
                "    red_model: art.Model,\n",
                "    rollout_id: int,\n",
                "    step: int,\n",
                ") -> Dict[str, Dict[str, art.Trajectory]] | Exception:\n",
                "    \"\"\"\n",
                "    Play one rollout, i.e. one game, return trajectories for every player.\n",
                "    For each rollout, we return four trajectories: red spymaster, red operative, blue spymaster, blue operative.\n",
                "    We conduct the game, caluclate the reward for each trajectory, report to OpenPipe, and return the trajectories.\n",
                "    \"\"\"\n",
                "    player_classes = {\"spymaster\": LLMSpymaster, \"operative\": LLMOperative}\n",
                "    player_dict: Dict[str, Dict[str, LLMSpymaster | LLMOperative]] = {\n",
                "        \"blue\": {\n",
                "            role: player_classes[role](team=\"blue\", model=blue_model)\n",
                "            for role in (\"spymaster\", \"operative\")\n",
                "        },\n",
                "        \"red\": {\n",
                "            role: player_classes[role](team=\"red\", model=red_model)\n",
                "            for role in (\"spymaster\", \"operative\")\n",
                "        },\n",
                "    }\n",
                "\n",
                "    try:\n",
                "        winner, reason = await run_game(\n",
                "            gs=game_state,\n",
                "            blue_spy=player_dict[\"blue\"][\"spymaster\"],  # type: ignore\n",
                "            blue_op=player_dict[\"blue\"][\"operative\"],  # type: ignore\n",
                "            red_spy=player_dict[\"red\"][\"spymaster\"],  # type: ignore\n",
                "            red_op=player_dict[\"red\"][\"operative\"],  # type: ignore\n",
                "        )\n",
                "    except Exception as e:\n",
                "        return e\n",
                "\n",
                "    # ── build art trajectories ──\n",
                "    game_metrics = {\n",
                "        \"ended_in_error\": 1 if game_state.game_ended_in_error else 0,\n",
                "        \"ended_in_assassin\": 1 if game_state.game_ended_in_assassin else 0,\n",
                "        \"ended_completely\": 0\n",
                "        if (game_state.game_ended_in_error or game_state.game_ended_in_assassin)\n",
                "        else 1,\n",
                "        \"total_turns\": game_state.turn_count,\n",
                "        \"total_words_left\": game_state.words_left[\"blue\"]\n",
                "        + game_state.words_left[\"red\"],\n",
                "        \"winning_color\": 1 if winner == \"blue\" else 0,\n",
                "    }\n",
                "\n",
                "    op_client = AsyncOpenPipe()\n",
                "    trajectory_dict: Dict[str, Dict[str, art.Trajectory]] = {}\n",
                "\n",
                "    for team in (\"blue\", \"red\"):\n",
                "        for role in (\"spymaster\", \"operative\"):\n",
                "            player = player_dict[team][role]\n",
                "            role_key = f\"{team}_{role}\"\n",
                "            # finish conversation with final message\n",
                "            events = game_state.format_events_for_player(role_key)\n",
                "            if events:\n",
                "                player.conversation.append({\"role\": \"user\", \"content\": events})\n",
                "            player.conversation.append(\n",
                "                {\n",
                "                    \"role\": \"user\",\n",
                "                    \"content\": f\"Game over. {winner} won. Reason: {reason}\",\n",
                "                }\n",
                "            )\n",
                "\n",
                "            reward = create_margin_reward(player, role_key, game_state, winner, reason)\n",
                "            mc = create_mc(player)\n",
                "            traj = art.Trajectory(\n",
                "                messages_and_choices=mc,\n",
                "                reward=reward,\n",
                "                metrics={\"reward\": reward, **game_metrics},\n",
                "            )\n",
                "            trajectory_dict.setdefault(team, {})[role] = traj\n",
                "\n",
                "            # report to OpenPipe for observability (best‑effort)\n",
                "            try:\n",
                "                await op_client.report(\n",
                "                    req_payload={\n",
                "                        \"model\": f\"{player.model.name}_{team}\",\n",
                "                        \"messages\": player.conversation,\n",
                "                        \"metadata\": {\n",
                "                            \"game_id\": game_state.game_id,\n",
                "                            \"rollout_id\": rollout_id,\n",
                "                            \"step\": step,\n",
                "                            \"role\": role,\n",
                "                            \"team\": team,\n",
                "                            \"num_turns\": game_state.turn_count,\n",
                "                            \"blue_words_left\": game_state.words_left[\"blue\"],\n",
                "                            \"red_words_left\": game_state.words_left[\"red\"],\n",
                "                            \"winning_color\": winner,\n",
                "                            \"game_end_reason\": reason[:1000],\n",
                "                            \"reward\": reward,\n",
                "                        },\n",
                "                    },\n",
                "                    resp_payload={\n",
                "                        \"id\": f\"chatcmpl-{uuid.uuid4()}\",\n",
                "                        \"object\": \"chat.completion\",\n",
                "                        \"created\": int(time.time()),\n",
                "                        \"model\": f\"{player.model.name}_{team}\",\n",
                "                        \"choices\": [\n",
                "                            {\n",
                "                                \"index\": 0,\n",
                "                                \"message\": {\"role\": \"assistant\", \"content\": \"dummy\"},\n",
                "                                \"finish_reason\": \"stop\",\n",
                "                            }\n",
                "                        ],\n",
                "                        \"usage\": {\n",
                "                            \"prompt_tokens\": 0,\n",
                "                            \"completion_tokens\": 0,\n",
                "                            \"total_tokens\": 0,\n",
                "                        },\n",
                "                    },\n",
                "                    status_code=200,\n",
                "                )\n",
                "            except Exception as e:\n",
                "                if DEBUG:\n",
                "                    print(f\"OpenPipe report failed: {e}\")\n",
                "\n",
                "    return trajectory_dict\n",
                "\n",
                "\n",
                "async def conduct_games(\n",
                "    blue_model: art.Model,\n",
                "    red_model: art.Model,\n",
                "    num_rollouts_per_game: int,\n",
                "    game_id: int,\n",
                "    step: int,\n",
                ") -> List[art.TrajectoryGroup]:\n",
                "    \"\"\"\n",
                "    Play *num_rollouts_per_game* games concurrently for a fixed board.\n",
                "    The fixed board provides the same starting state for each rollout.\n",
                "    \"\"\"\n",
                "    base_state = create_game(game_id=game_id)\n",
                "\n",
                "    rollout_results = await asyncio.gather(\n",
                "        *[\n",
                "            run_single_rollout(\n",
                "                game_state=copy.deepcopy(base_state),\n",
                "                blue_model=blue_model,\n",
                "                red_model=red_model,\n",
                "                rollout_id=rid,\n",
                "                step=step,\n",
                "            )\n",
                "            for rid in range(num_rollouts_per_game)\n",
                "        ]\n",
                "    )\n",
                "\n",
                "    groups: Dict[str, List[art.Trajectory]] = {}\n",
                "    for res in rollout_results:\n",
                "        if isinstance(res, Exception):\n",
                "            continue\n",
                "        for team in (\"blue\", \"red\"):\n",
                "            for role in (\"spymaster\", \"operative\"):\n",
                "                groups.setdefault(f\"{team}_{role}\", []).append(res[team][role])\n",
                "\n",
                "    return [art.TrajectoryGroup(trajs) for trajs in groups.values()]\n",
                "\n",
                "\n",
                "async def _run_single_validation_game(\n",
                "    game_id: int,\n",
                "    my_model: art.Model,\n",
                "    benchmark_model: art.Model,\n",
                "    step: int = 0,\n",
                ") -> art.Trajectory | Exception:\n",
                "    \"\"\"\n",
                "    Creates a single game of Codenames, alternating your model and the benchmark model\n",
                "    (e.g. GPT-4o) between Blue and Red. Returns a list of your model’s Trajectories only, with the reward\n",
                "    for each set to 1 if your model won, and 0 otherwise.\n",
                "    \"\"\"\n",
                "\n",
                "    # Create a fresh game state\n",
                "    game_state = create_game(game_id=game_id)\n",
                "\n",
                "    # Alternate which side your model takes\n",
                "    if game_id % 2 == 0:\n",
                "        my_team, _other_team = \"blue\", \"red\"\n",
                "        blue_model, red_model = my_model, benchmark_model\n",
                "    else:\n",
                "        my_team, _other_team = \"red\", \"blue\"\n",
                "        blue_model, red_model = benchmark_model, my_model\n",
                "\n",
                "    # Run a single rollout (one game) using your existing code\n",
                "    trajectory_dict = await run_single_rollout(\n",
                "        game_state=copy.deepcopy(game_state),\n",
                "        blue_model=blue_model,\n",
                "        red_model=red_model,\n",
                "        rollout_id=game_id,\n",
                "        step=step,\n",
                "    )\n",
                "\n",
                "    if isinstance(trajectory_dict, Exception):\n",
                "        return trajectory_dict\n",
                "\n",
                "    winning_color = (\n",
                "        \"blue\"\n",
                "        if trajectory_dict[\"blue\"][\"spymaster\"].metrics.get(\"winning_color\", \"\") == 1\n",
                "        else \"red\"\n",
                "    )\n",
                "\n",
                "    my_traj = trajectory_dict[my_team][\"spymaster\"]\n",
                "    my_traj_reward = 1.0 if my_team == winning_color else 0.0\n",
                "\n",
                "    # Overwrite the reward in the trajectory\n",
                "    my_traj.reward = my_traj_reward\n",
                "    my_traj.metrics[\"win_rate\"] = my_traj_reward\n",
                "    my_traj.metrics[\"reward\"] = my_traj_reward\n",
                "\n",
                "    return my_traj\n",
                "\n",
                "\n",
                "async def run_validation_games(\n",
                "    my_model: art.Model,\n",
                "    benchmark_model: art.Model,\n",
                "    num_validation_games: int = 50,\n",
                "    step: int = 0,\n",
                ") -> List[art.Trajectory]:\n",
                "    \"\"\"\n",
                "    Creates `num_validation_games` games of Codenames, concurrently running them via asyncio.gather,\n",
                "    alternating your model vs. benchmark model (e.g. GPT‑4o) between Blue and Red.\n",
                "\n",
                "    Returns a flat list of your model’s trajectories. Each trajectory has a reward of 1 if your\n",
                "    model’s team won, and 0 if it lost.\n",
                "    \"\"\"\n",
                "    tasks = [\n",
                "        _run_single_validation_game(\n",
                "            game_id=gid,\n",
                "            my_model=my_model,\n",
                "            benchmark_model=benchmark_model,\n",
                "            step=step,\n",
                "        )\n",
                "        for gid in range(num_validation_games)\n",
                "    ]\n",
                "\n",
                "    # Run all validation games concurrently\n",
                "    result_trajectories = await tqdm_asyncio.gather(\n",
                "        *tasks, desc=\"Running validation games\", total=num_validation_games\n",
                "    )\n",
                "\n",
                "    return [t for t in result_trajectories if not isinstance(t, Exception)]"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# Model and Training Loop\n",
                "\n",
                "<a name=\"Loop\"></a>\n",
                "\n",
                "First, we create a trainable model which gives ART a spec of the model we want to train.\n",
                "Next, we create a backend, which could be local or point to a remote server which has art installed.\n",
                "We then register the model with the backend, letting the backend know where we will be training the model.\n",
                "You then have an openai client for your model, which will automatically point to the latest version of the model under training.\n",
                "\n",
                "For the training loop, we conduct training games and every 5 steps, we conduct validation games against val benchmark model.\n",
                "For every training step, we gather the trajectory groups from each starting position, flatten into groups, and then train the model on these groups.\n",
                "\n",
                "We provide additional benchmaking code to see how the model performs over time when compared to off the shelf models like gpt-4.1-nano and gpt-4.1-mini.\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "colab": {
                    "base_uri": "https://localhost:8080/",
                    "height": 1000,
                    "referenced_widgets": [
                        "e72428e058f348948cd726e1a3729098",
                        "cbd009b937164b858616bc905477bbf7",
                        "9018da7fa4064e7e98b3fb324410e6c6",
                        "195ee9f5e81e451d8129ce5ab1c2e729",
                        "aa6adc4f548d47ee8595ff59cf5821e1",
                        "0523c414de1440eb8c01094380b13edc",
                        "2e660693841847a6be9b258b61076998",
                        "040444ba48bb42ed8857cf41b215bd42",
                        "f2b6000bd7a64bd6bdd3d81cc1f62eac",
                        "34214a86e73f490782c0eb0ed3834eba",
                        "1753b897ff0f4d838add350945d5a47c",
                        "22141322fd484feb8056db79a50b6acc",
                        "f804a7bb942d461e8521da23efdf8b2b",
                        "4eb899bbf4ab4297bb63cca9ec848fed",
                        "2edba5c0183f4544a63a1ae288ece545",
                        "f5896acf3bd44c87b791d682465ce2c0",
                        "12b8226d967b4b25bf80959a92cbf752",
                        "2c21b567dfea400884559ad6835ad460",
                        "ba57f6ece88a4f42b5deafef0046b3da",
                        "08c53586bef94e2b9a6d88feeb0847a8",
                        "e9987113a053438ba9bb38b8522304f4",
                        "04ef72524aee43e09e2067f36420c089",
                        "853862cceee14a9186ad54e9ef7330c4",
                        "1d35d988790d4cab90df0b6ac32e8d13",
                        "8042b59f138b41d3b8e09e95b9121852",
                        "49adf8f932dd41ce920d97b438e19d02",
                        "02290c92aad149dcbc493ecd1e8e9fea",
                        "5116155feb8c4cf78ad6b07e71088c47",
                        "a773f7bdae6947b68c08ac4dbc623082",
                        "47b720604f7b4e30976262a51b8aa8cb",
                        "cddfe2eeefd443d8b5b8981fb0572b15",
                        "07760b73e12342a9be176e7d6ee9d6c9",
                        "9d1af65f2aea4835b65ee50635622279",
                        "15ec6e95bdc744b7b1b065b84131474d",
                        "c9598c8f119a40bfa0e19146d4d4d229",
                        "fe3436fd54034c48a5d535118fb0d365",
                        "4aa808fcfb364054bdda121436078852",
                        "86641b31fdf1464688d07e38a1a976e0",
                        "362772bb65354d93b803303f15069d1e",
                        "b371a055ed7d4643bf94d69084176100",
                        "8a528b27c5434f98a4d2603af186ec33",
                        "5c01df94ffc2445a8ebe3fc057d935b3",
                        "0d71a2269efc42dc867d9ccaff87563b",
                        "d379ae3921a242a7b54b62e4566f5242",
                        "8644b166625f41ea9ed9f90906d80b12",
                        "33861aee8d6348068ecf40d550521f05",
                        "2c2c1e1cfff649199376a551014645e6",
                        "6014ba69ec8942969a20ca018f943edd",
                        "babcc45b3e8845d6b1d30c976298ab3c",
                        "4bea909a1dfb49b482a1fbb790319c36",
                        "f09bca3e57b446a3acb13072bf7810fc",
                        "a10bc0dcee5f4873a6cbae6e6ff2ed2b",
                        "f411c37c9e024633998bc3c5a5f813f8",
                        "7e20b273def349b8be145c611b50e2c5",
                        "f7743efea02d4e0b803d070bca54e004",
                        "8a102b3727584b5f86cbaa8f0cfc58b1",
                        "3246401c2ade4c479e5b780622fe5281",
                        "2d20dde71d2044048e4c8b99ce214f7a",
                        "47fc855728df4646afcf58d218dc8156",
                        "f09687df74dd4f7cb7e6fa94bad314c5",
                        "5ce63265c07c425f857243c258a56e50",
                        "45a9a6ff4c9b4720a7f39b2ef7518536",
                        "62aa66c791a54eb884b11b8733cac3a9",
                        "45b18f05f1874f1aa6ff683553f204e5",
                        "0a4206c6bc5646e4bfd017c2276392dd",
                        "22dd66faf65642408a298feabe5b3dab",
                        "bd5c8ca26ba241a3a3fbfa34ae5a42e8",
                        "a8f2fb6bc05742b9826e1ac78642d629",
                        "942bae5fc19f44ffa588b4db93733527",
                        "74e009de22b34a949b6e9b367347914c",
                        "1d6969b64dec47508f2f716669e8f88e",
                        "6fa77b3097974d1185a0934823b25ebf",
                        "81160027b13a4cfbb0137358a5a18844",
                        "6174e23f957543d08661ede8e410a375",
                        "744a164e6adb4389b9ab993a632fa5a8",
                        "3756e9c62ef3405d847f766fc2211209",
                        "5142a2a9e3964a1aabf62b7489afab8c",
                        "3195b655571c4e24b747c6665b07ddb9",
                        "91c9f3f575e547d4a92b186518277248",
                        "c2807fd005a3428d9b1da0f74c155367",
                        "0739fda46db3400b9918607b6c976954",
                        "85d8704317b145a284ea009f73f599f6",
                        "239972e76f434670b543f2e756b921cd",
                        "197e03fe3c354365a82edf064cdf5efe",
                        "1c400a0bd2004651aa86119c5a12dd6f",
                        "864fc4f4012d488b894e18eb234138e9",
                        "3d9a8a49b0944e8daac775da8feea31e",
                        "9cb76b0988744277be5f2454f80d88ca",
                        "dcf2aabe19334e46a2971a5f014c8b81",
                        "84d580e9b0724bd9bdba0b167880e465",
                        "43f34c356d974a04b697567ca3d03853",
                        "165bef62dcdb4ae7a4fde12e2f8f123c",
                        "89a8cfedcd4f4129a82167768c1ce8cd",
                        "7ab3a2cd201f43858dcf340a3c28bc28",
                        "c178a52e60a240f392512fe62d9747c8",
                        "f09738e028ce4442acb3cb5654c82bf0",
                        "aaf37fed21ce4f3bbe920b89bb7bce5f",
                        "d9af677719534392b9c57228d467c8d7",
                        "66ae19f2a60949a690b56500219564a3",
                        "f151c46e4bd24d26b7d6e4beb40a75cc",
                        "929dc22fe1a04a64904266fb0f2953b3",
                        "8a2d7780b3d046389d95c28debc8b4d2",
                        "4621a988f587442cb1bbd644befdf87d",
                        "17c1ac20602d43c2a99d4fea1003d2a4",
                        "4b98267db7c9439ea2707828776dbc60",
                        "6c57a7f6d24c4b208c41991ec8cd8a23",
                        "4dbd1597889b45bbb90475178d847599",
                        "2026a53197334c28ad55be1fbd5b4766",
                        "1d63bc6c3c864e528c255c511017251b",
                        "ca785d8397814836b23c5c467591cbb9",
                        "3295993bc814480dba075b9b675bb5b2",
                        "7a8b1c9031184b3f94d4af37ba218989",
                        "53ef5c97926a4c79983d53ccc2c96f1b",
                        "ba74b8d8213847918b95d4dbf2a149e0",
                        "95e4c8e486c445ab99ed5c61ea0e5dbe",
                        "362749366a25491c9052194aef17501c",
                        "7a2759a96924497d8595c9e77fcf1e17",
                        "c6591df35c624cfeaa5893108740bec7",
                        "48a264dc11be4ca8a687077bf6ee9ace",
                        "98e37477b914493a8ba993041ae126c1",
                        "c9bd0933e36d487e8e332b26c27e1841",
                        "602ad9dc58d647e09b485311fcfb27a6",
                        "24fb7e0dbdcd4d098c2317b4f6fbc143",
                        "2fc649ba50b8404eab7b9e587068cef0",
                        "4d7ddc5d009f45d69b3704563ed83020",
                        "70789624c8a0434bac2514da220f620f",
                        "5dac4cb8f6e6411180ccfaf1c0c10b6a",
                        "6ecd74627f5047e28d4bbf885492e516",
                        "10d9f692158b4331a51b487b05e266c6",
                        "ce72510d4d7e40cf9129e89483907797",
                        "fbacbbfcfd9441f5b30bff1f45684e78",
                        "2537d45e3af94d05b4a554d8965b2c13",
                        "ff6f94dff3924164afef49a113706d76",
                        "9c811d5ca58043acb0d305cda9a85d24",
                        "12b7f9314f0e4f02afb5982782aac5b2",
                        "62a853096e5f4bc2957074aa6ebd7b9b",
                        "8162ebae91c649eb8b266917bb0fd3c9",
                        "cbf54a7eb539479a88b030edcbcde28e",
                        "d7a7c4411b2f4898b009e3f5d9460c37",
                        "76412d9bead24948b42a66d158c09a7f",
                        "d817ecba0b8744d1ac95ce6d9aeca2f0",
                        "2238114fd33441d592ccba6e6e33ec05",
                        "c61152addc5048dbbe5728e7adffe935",
                        "ea00bf8c54dd43deb9e6cb5fdd7233d0",
                        "84ad6b74b1494fababb4e3e24e39680e",
                        "d26b8272075f44249bde5d1a6c1ecae3",
                        "eab41332b23e4d32b89efa462b2c2069",
                        "65867938f17447b68796177cd43b791f",
                        "8cdcfb368f88496780358deb2070f414",
                        "b17cb184acdf4fb68ccd38ed821baadb",
                        "9ff54243037a4582b83f63268d30bcdb",
                        "b3fc29f979154931adf108e02d83d213",
                        "c639a82a017e46f1b576d932babfd665",
                        "d07dd2c30dbd40328ba28d387e4a9c88",
                        "5fb57abdfc3844c6819f61816cd8a124",
                        "d4f206c87af64c92a4fac8490ccebcde",
                        "175abdc319784cd28b5ba0b3bab9f483",
                        "1e0b830a731b453985b27f6b2dd0caf6",
                        "a7404c4a2908422f81cfc4e8b6a38703",
                        "73f74524e25c484ea48c2cf47e49da19",
                        "9ddec071eb9f4ef3aa134604a3ccd61e",
                        "664039da0e5549df8cf3f290dbf69954",
                        "bdfdbb9d873749d5b3b6a8da3e895be5",
                        "f4f5c65fd9334a3ab46885e1b0d9fa4e",
                        "9a4fc53439874a4aa8bb8800cf7bf350",
                        "9608266edcc440e180f0f4b65585c86a",
                        "99411ff3c09a4324a8d5770165d14d95",
                        "85f9950ee48f4b3488c26a6a5e2a3486",
                        "7d88ecf2010a45f5a76cc2b207ec754d",
                        "aeed7b071b5a413395438db238c6a487",
                        "cf57767f3c454b08a3f73dcdbba5909c",
                        "3be68d2584bc447faf0cc1683bd1784e",
                        "f6c0f33cd959448eb4eb6f5ebb7e8260",
                        "3b84d9d78c304e6e860a4bb29b6d1f77",
                        "dbc62f8b6dc147f7b134e533baf75142",
                        "1ef74d71bd664415b851a92288c2ba86",
                        "2b2c15eeca9347f19df53f7473386bc8",
                        "50982da7787d4caebe0c905598b45837",
                        "ca8ef36c33754dc7b8a653f1cf27da63",
                        "a2d0b59f8de34b01abeb700e473c745a",
                        "1303f1e29476462c9e74f3d7d0bd77b8",
                        "6cd9c2f540ae4dc9b8dc122fd36b45ab",
                        "9d988a10bd284ffeaf21e87d091d3a02",
                        "f192f0e9170f4667a25fc8478ab6c090",
                        "7bd20baaa4984507bc77853341648f43",
                        "ef2fe0a8702f4ed6a239513317c34dbe",
                        "5c2bd87adc54429b98f5560f93122090",
                        "0be06094eb744169ae16079bf72ccc01",
                        "19ccc7ceb30944ef94cafe02bad769e1",
                        "5eff7bfef19e4c03b5e01c940e785b10",
                        "eb70765a3a8e48bfbf821a3e8a120a3c",
                        "ec05686ef1524d30b47ab315e59e721d",
                        "38373cd3e3c343128e7c685c0c438186",
                        "a695620b400749a2af6a25398cf062e6",
                        "229b9df342f54700b6b81e85101f3402",
                        "233aaf246e3045e59e1a6c08e45d0bd4",
                        "884f53ddcf04417cb3fc4726f614c654",
                        "d90875bcc5984530b53f1447fd35446c",
                        "6a89117e07fb4d7b932fa50d16a96ced",
                        "7b39c02e6ed941d6b838d22aa6ead716",
                        "aa7cf1df8d164cbe8c9eac6ad2dec698",
                        "6950df7a87824f9690cf95c9b3526d28",
                        "d251517b3307436ebaea46c2d6e7307b",
                        "1df0adace6d049baa28977d51da6aba3",
                        "26f8ee815c9d4ea7900f345ea17cb319",
                        "2e0804fbc3234cbdaefc9d1f34e18f25",
                        "c53c069d9c6b45b09c62ccb63a9a67c5",
                        "8a532ab783d44324a07244e02a75710f",
                        "96b93723f5914373af5aff858d39fb09",
                        "43e83e815b9944729c1cca4047770bce",
                        "d065fa7e3cbd4584b55130567b57232a",
                        "476ba9b07fec4c88b9e1596cad6f7e77",
                        "bbefe65514be4a3fac86543b86c22e29",
                        "5c47e859d6b24a379f77f67ee878c635",
                        "a954994a18f146a3826fc6e3baa16dd5",
                        "d9785f4d3f3741319aa00e8d5645f5c6",
                        "69849c44d5ca4ae78ac8e74075f6bb45",
                        "a355071a61bb4173b207e94b9880cf14",
                        "ccbf70af73dc4bc5a513d55ec636b10a",
                        "35735588567a425b9fceaaf02266f521",
                        "99ab5eb94efb435b8438186a83e3da74",
                        "bf1bbdee17454e47a4a0984c1a71875f",
                        "f0aebcf242a743db9dfeb040b0ca6d06",
                        "2a339586dea945c682da5a923939a64f",
                        "7b030179cc7d4f919f2284938fc2c2a0",
                        "fbee4546cd424451828331036fce6d91",
                        "2a20c15de6ce4f8a99073c1464c2c699",
                        "ca85d0e806604038b562639bf5b2c4f9",
                        "0ae053dd255440f29b87d27ab6bd615f",
                        "72ab2716699c402392f603fb32afe733",
                        "0a40a6d824eb4640b059eb24b861eaed",
                        "d27cfc09589a4bbcba41f45920267c1e",
                        "af757b4fb45749999ad059f5cd9fc760",
                        "516ba835db8e4f57bb20034e8c97d8a4",
                        "0d82767cd3b848e28816ee4fe58afb54",
                        "66acc2fb207c40f5bc081f338ab73014",
                        "0bde75f1fe554d46b4ba499dfad16466",
                        "1a190e4730f24f8d89c12a7f0a75ff80",
                        "a70a0a7d18354a4e8fecde3215ab8edb",
                        "abdbe64c8ed441c78fde80226ad7f0a5",
                        "392fb4b81f7f4a9998816d3738ddcf9c",
                        "143873680ad044d8a378338a361da91d",
                        "fe2def2b98a54c6999302e1bca1ff4ac",
                        "034439ae2d2c4e36b183124c9bef0215",
                        "aeb915b55cc0429b8d76c6536942c6f0",
                        "2b7268a59bf24c9389178bb2235cefdb",
                        "8707ca61809f425d9bb6413bc93015a0",
                        "3bddffc1ebb94c73893a61905cbe8a1e",
                        "ee8c08a08fee4b558546a1c2ca86e0c0",
                        "f4949c53b94242859015e631742a2c9a",
                        "6b73f5543dde4affb00c22094285cfff",
                        "e566136ced9045b6b01e16cb2b28d0c3",
                        "6adc6a35d7b74fea8f9f10a72a5c49f1",
                        "f444064a92b44520a2e5ae718d15db15",
                        "3906a49aef0b4a2fa2d021de46107de5",
                        "5080ff29c7eb4a528448891b48c4549f",
                        "7db5f913557f4be7ba60c61a28618950",
                        "15069cc401ed478aaee837a2a78207b3",
                        "bbd2510a62e446eea17caab661c1869f",
                        "21d883d41f5d481f815e15a46ba0850e",
                        "c9fd113558884bf58eb52ced000c10dc",
                        "b0c4cf38c4bb424aa46accc8a4f65e19",
                        "9790f1b688134985af8fcb0eac462799",
                        "70d3c61a0cbc423a908e9be82cc46b62",
                        "7f0756ae2cff495ab60f780c28a2282d",
                        "092dfdb2f9664bb199e1919214ac02d7",
                        "221a6f7511e24e489d445dd2a849e36a",
                        "1f6fec2cecae43b692a063825e4c6c7e",
                        "e7211fd4b8ed4b788f7c7054d13601c1",
                        "d6cf727244864adb9719e6e065b5e44a",
                        "402d1c802da841cc9a0ccdb7e4972887",
                        "69788c5a8bdd4b6b8594176d4e96edb8",
                        "5596e61201e7467a960aa1bed0e1ff41",
                        "63bd2198a5714c7d876796bdbbf80ec1",
                        "51082dc5b2f1462fabfd662b3b676e44",
                        "95d483347fc44a6faffa775595c1e1cc",
                        "da58d554a12e4d56a0dda0700801eea3",
                        "a324f388c01741db8554d0270540357c",
                        "8ae1de8215db4f3e845be44e4c92b290",
                        "20fc0f86413c4c5c8a3d621911495e33",
                        "c3d1740cbbb64bc0a3c094e9213f0baa",
                        "32eb80676ade418fae17df8f160f1d3f",
                        "a4e2c15f81794358a6d36317ccb355ea",
                        "e70422f9bc414297a82f73a0de9490f1",
                        "b763e71ff2534ed1b1ff7583be6c0ff3",
                        "2678ba8e36214093a417b7142df4306e",
                        "433e63bd205b4163904a7003699030e7",
                        "8d869aa2c3ca4f67855c36f8d6dfde39",
                        "c2c9fe0462a94c3583ef9df8ec87cfb5",
                        "9baa4a7086d04758aa398c7818fea33a",
                        "45aeb09d5da54706b3dc52ce640cbccf",
                        "9adaf14b1bb3405db4eef99c59b9a9ee",
                        "06528880ed704d49ad38570bb45b1645",
                        "41e18cca19c941bbac40c1eb5656df43",
                        "c29771a697844221abfaef34271684bd",
                        "49f23db3c6c7434db5c6f8df563cfb63",
                        "5336e8dacff843f2a51a848a8f841005",
                        "4aa6e9dc22f54b7dbaf1cef71b1efc72",
                        "abf14bca6083454caa1ba6770549c224",
                        "cae553010dc841e3841b82cfe9e1ed91",
                        "8a8c87a91ac84d8e85148d661d0ccd73",
                        "f5b18d1c202f4787b661154abd44a34b",
                        "c0b695e0436c41a2b620a945f80ef048",
                        "dd97010673604f8fb77498c435de3c78",
                        "0634b7399980456e994967b36efc1ab3",
                        "1b67a348abfc47ee9b01c0415351d636",
                        "45b8e7999b8d4ff2a9781eac2d57d2cb",
                        "adf9890e6a68491a8ba13a7b51631b40",
                        "deb7903cf0704446886ef371741e43b0",
                        "1d78f5f979074a179aae862a9c9cb76e",
                        "45efb400acc9489da13bd8ca3bae0a4d",
                        "b60e5aed65244123885278f96e3b8e6a",
                        "5c646ff1453348f6aa43e543594aebd5",
                        "0dc3f237832841df887d5bb5494bbe7f",
                        "6ea7dce780bc40ddb92b79c7c67989cf",
                        "caa5de4861a243f788fddc4f95d005c6",
                        "d5347fdc5eb54c8b952d5d164b64103f",
                        "39d3262a559e4416be22ebb2c60ef81f",
                        "a9ad261bb96043c991919ad792c0b8f2",
                        "2eb9641061634c5d801f9ab43c7d8c4c",
                        "e0d25670d6de449ca9eec7ad5dee7ddb",
                        "e5b4a665b14b4ed3a746acd56705de04",
                        "a82db63b14d74095b40860394b439be4",
                        "edca4e55f5fc4860bb123bcb8fba76ec",
                        "341ed8d9afef493287def27d89a03dfd",
                        "561b19773b4d443f8a976b4c4bfe4777",
                        "4dba60aca98849b3b65b98fdf5037ddb",
                        "7573a59395b34380aedf55b75a8d3e97",
                        "9e201be0fd834e6e9eee25c1ce998b4f",
                        "7e3a1309e6dd422785531cf4090b2417"
                    ]
                },
                "id": "KZIiZ1VkrEUy",
                "outputId": "27e0f41a-a993-488d-c86b-3749e006f121"
            },
            "outputs": [
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "2025-05-06 06:34:12,382\tINFO util.py:154 -- Missing packages: ['ipywidgets']. Run `pip install -U ipywidgets`, then restart the notebook server for rich notebook output.\n",
                        "/workspace/ART/src/art/__init__.py:11: UserWarning: WARNING: Unsloth should be imported before transformers, peft to ensure all optimizations are applied. Your code may run slower or encounter memory issues without these optimizations.\n",
                        "\n",
                        "Please restructure your imports with 'import unsloth' at the top of your file.\n",
                        "  import unsloth  # type: ignore\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "🦥 Unsloth: Will patch your computer to enable 2x faster free finetuning.\n",
                        "Unsloth: Failed to patch Gemma3ForConditionalGeneration.\n",
                        "🦥 Unsloth Zoo will now patch everything to make training faster!\n",
                        "INFO 05-06 06:34:43 __init__.py:207] Automatically detected platform cuda.\n",
                        "Standard import failed for UnslothDPOTrainer: No module named 'UnslothDPOTrainer'. Using tempfile instead!\n",
                        "==((====))==  Unsloth 2025.3.19: Fast Qwen2 patching. Transformers: 4.51.3. vLLM: 0.7.3.\n",
                        "   \\\\   /|    NVIDIA H100 80GB HBM3. Num GPUs = 1. Max memory: 79.205 GB. Platform: Linux.\n",
                        "O^O/ \\_/ \\    Torch: 2.5.1+cu124. CUDA: 9.0. CUDA Toolkit: 12.4. Triton: 3.1.0\n",
                        "\\        /    Bfloat16 = TRUE. FA [Xformers = 0.0.28.post3. FA2 = False]\n",
                        " \"-____-\"     Free license: http://github.com/unslothai/unsloth\n",
                        "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n",
                        "Unsloth: vLLM loading unsloth/qwen2.5-3b-instruct-unsloth-bnb-4bit with actual GPU utilization = 78.4%\n",
                        "Unsloth: Your GPU has CUDA compute capability 9.0 with VRAM = 79.2 GB.\n",
                        "Unsloth: Using conservativeness = 1.0. Chunked prefill tokens = 32768. Num Sequences = 368.\n",
                        "Unsloth: vLLM's KV Cache can use up to 59.87 GB. Also swap space = 6 GB.\n",
                        "INFO 05-06 06:35:16 config.py:549] This model supports multiple tasks: {'score', 'generate', 'reward', 'classify', 'embed'}. Defaulting to 'generate'.\n",
                        "Unsloth: vLLM Bitsandbytes config using kwargs = {'load_in_8bit': False, 'load_in_4bit': True, 'bnb_4bit_compute_dtype': 'bfloat16', 'bnb_4bit_quant_storage': 'uint8', 'bnb_4bit_quant_type': 'nf4', 'bnb_4bit_use_double_quant': True, 'llm_int8_enable_fp32_cpu_offload': False, 'llm_int8_has_fp16_weight': False, 'llm_int8_skip_modules': ['lm_head', 'multi_modal_projector', 'merger', 'modality_projection', 'model.layers.2.mlp', 'model.layers.3.mlp', 'model.layers.30.mlp'], 'llm_int8_threshold': 6.0}\n",
                        "INFO 05-06 06:35:18 llm_engine.py:234] Initializing a V0 LLM engine (v0.7.3) with config: model='unsloth/qwen2.5-3b-instruct-unsloth-bnb-4bit', speculative_config=None, tokenizer='unsloth/qwen2.5-3b-instruct-unsloth-bnb-4bit', skip_tokenizer_init=False, tokenizer_mode=auto, revision=None, override_neuron_config=None, tokenizer_revision=None, trust_remote_code=False, dtype=torch.bfloat16, max_seq_len=32768, download_dir=None, load_format=LoadFormat.BITSANDBYTES, tensor_parallel_size=1, pipeline_parallel_size=1, disable_custom_all_reduce=False, quantization=bitsandbytes, enforce_eager=False, kv_cache_dtype=auto,  device_config=cuda:0, decoding_config=DecodingConfig(guided_decoding_backend='xgrammar'), observability_config=ObservabilityConfig(otlp_traces_endpoint=None, collect_model_forward_time=False, collect_model_execute_time=False), seed=0, served_model_name=unsloth/qwen2.5-3b-instruct-unsloth-bnb-4bit, num_scheduler_steps=16, multi_step_stream_outputs=True, enable_prefix_caching=True, chunked_prefill_enabled=False, use_async_output_proc=True, disable_mm_preprocessor_cache=False, mm_processor_kwargs=None, pooler_config=None, compilation_config={\"level\":0,\"splitting_ops\":[],\"compile_sizes\":[],\"cudagraph_capture_sizes\":[368,360,352,344,336,328,320,312,304,296,288,280,272,264,256,248,240,232,224,216,208,200,192,184,176,168,160,152,144,136,128,120,112,104,96,88,80,72,64,56,48,40,32,24,16,8,4,2,1],\"max_capture_size\":368}, use_cached_outputs=False, \n",
                        "INFO 05-06 06:35:19 cuda.py:229] Using Flash Attention backend.\n",
                        "WARNING 05-06 06:35:19 registry.py:335] `mm_limits` has already been set for model=unsloth/qwen2.5-3b-instruct-unsloth-bnb-4bit, and will be overwritten by the new values.\n",
                        "INFO 05-06 06:35:20 model_runner.py:1110] Starting to load model unsloth/qwen2.5-3b-instruct-unsloth-bnb-4bit...\n",
                        "INFO 05-06 06:35:20 loader.py:1089] Loading weights with BitsAndBytes quantization.  May take a while ...\n",
                        "INFO 05-06 06:35:20 weight_utils.py:254] Using model weights format ['*.safetensors']\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "Loading safetensors checkpoint shards:   0% Completed | 0/1 [00:00<?, ?it/s]\n",
                        "Loading safetensors checkpoint shards: 100% Completed | 1/1 [00:00<00:00,  1.69it/s]\n",
                        "Loading safetensors checkpoint shards: 100% Completed | 1/1 [00:00<00:00,  1.69it/s]\n",
                        "\n",
                        "Loading safetensors checkpoint shards:   0% Completed | 0/1 [00:00<?, ?it/s]\n",
                        "Loading safetensors checkpoint shards: 100% Completed | 1/1 [00:00<00:00,  1.59it/s]\n",
                        "Loading safetensors checkpoint shards: 100% Completed | 1/1 [00:00<00:00,  1.59it/s]\n",
                        "\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "INFO 05-06 06:35:22 model_runner.py:1115] Loading model weights took 2.2265 GB\n",
                        "INFO 05-06 06:35:22 punica_selector.py:18] Using PunicaWrapperGPU.\n",
                        "INFO 05-06 06:35:27 worker.py:267] Memory profiling takes 4.73 seconds\n",
                        "INFO 05-06 06:35:27 worker.py:267] the current vLLM instance can use total_gpu_memory (79.20GiB) x gpu_memory_utilization (0.78) = 62.10GiB\n",
                        "INFO 05-06 06:35:27 worker.py:267] model weights take 2.23GiB; non_torch_memory takes 0.16GiB; PyTorch activation peak memory takes 2.71GiB; the rest of the memory reserved for KV Cache is 57.00GiB.\n",
                        "INFO 05-06 06:35:27 executor_base.py:111] # cuda blocks: 103764, # CPU blocks: 10922\n",
                        "INFO 05-06 06:35:27 executor_base.py:116] Maximum concurrency for 32768 tokens per request: 50.67x\n",
                        "INFO 05-06 06:35:31 model_runner.py:1434] Capturing cudagraphs for decoding. This may lead to unexpected consequences if the model is not static. To run the model in eager mode, set 'enforce_eager=True' or use '--enforce-eager' in the CLI. If out-of-memory error occurs during cudagraph capture, consider decreasing `gpu_memory_utilization` or switching to eager mode. You can also reduce the `max_num_seqs` as needed to decrease memory usage.\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "Capturing CUDA graph shapes: 100%|██████████| 49/49 [00:26<00:00,  1.84it/s]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "INFO 05-06 06:35:58 model_runner.py:1562] Graph capturing finished in 27 secs, took 1.30 GiB\n",
                        "INFO 05-06 06:35:58 llm_engine.py:436] init engine (profile, create kv cache, warmup model) took 35.75 seconds\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "Unsloth 2025.3.19 patched 36 layers with 36 QKV layers, 36 O layers and 36 MLP layers.\n"
                    ]
                }
            ],
            "source": [
                "# ───────────────────────────  7. Creating the model  ───────────────────────────\n",
                "from art.local import LocalBackend\n",
                "\n",
                "model = art.TrainableModel(\n",
                "    name=MODEL_NAME,\n",
                "    project=\"codenames-rl\",\n",
                "    base_model=BASE_MODEL_NAME,\n",
                ")\n",
                "\n",
                "benchmark_model = art.Model(\n",
                "    name=VAL_BENCHMARK_MODEL,\n",
                "    project=\"codenames-rl\",\n",
                "    inference_model_name=VAL_BENCHMARK_MODEL,\n",
                "    inference_api_key=os.getenv(\"OPENAI_API_KEY\"),\n",
                "    inference_base_url=\"https://api.openai.com/v1\",\n",
                ")\n",
                "\n",
                "backend = LocalBackend(path=\"./.art\")\n",
                "\n",
                "await model.register(backend)\n",
                "await benchmark_model.register(backend)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "id": "v2ESllEqjpla",
                "outputId": "e97995a9-649b-4b3a-cfcb-5392db8d9469"
            },
            "outputs": [
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "train: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████| 250/250 [02:46<00:00,  1.50it/s, loss=-0.265, grad_norm=0.295, policy_loss=-0.265]\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "iter 0: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [00:28<00:00,  2.90s/it]\n",
                        "Running validation games: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 50/50 [00:11<00:00,  4.37it/s]\n",
                        "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mopenpipe\u001b[0m (\u001b[33mopenpipe-team\u001b[0m) to \u001b[32mhttps://api.wandb.ai\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n"
                    ]
                },
                {
                    "data": {
                        "text/html": [
                            "Tracking run with wandb version 0.19.10"
                        ],
                        "text/plain": [
                            "<IPython.core.display.HTML object>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "data": {
                        "text/html": [
                            "Run data is saved locally in <code>/workspace/codenames-rl/wandb/run-20250506_063655-codenames_model_op_3</code>"
                        ],
                        "text/plain": [
                            "<IPython.core.display.HTML object>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "data": {
                        "text/html": [
                            "Syncing run <strong><a href='https://wandb.ai/openpipe-team/codenames-rl/runs/codenames_model_op_3' target=\"_blank\">codenames_model_op_3</a></strong> to <a href='https://wandb.ai/openpipe-team/codenames-rl' target=\"_blank\">Weights & Biases</a> (<a href='https://wandb.me/developer-guide' target=\"_blank\">docs</a>)<br>"
                        ],
                        "text/plain": [
                            "<IPython.core.display.HTML object>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "data": {
                        "text/html": [
                            " View project at <a href='https://wandb.ai/openpipe-team/codenames-rl' target=\"_blank\">https://wandb.ai/openpipe-team/codenames-rl</a>"
                        ],
                        "text/plain": [
                            "<IPython.core.display.HTML object>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "data": {
                        "text/html": [
                            " View run at <a href='https://wandb.ai/openpipe-team/codenames-rl/runs/codenames_model_op_3' target=\"_blank\">https://wandb.ai/openpipe-team/codenames-rl/runs/codenames_model_op_3</a>"
                        ],
                        "text/plain": [
                            "<IPython.core.display.HTML object>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Packed 160 trajectories into 12 sequences of length 2048\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "train:   0%|                                                                                                                                                                           | 0/12 [00:00<?, ?it/s]==((====))==  Unsloth - 2x faster free finetuning | Num GPUs used = 1\n",
                        "   \\\\   /|    Num examples = 10,000,000 | Num Epochs = 3 | Total steps = 30,000,000\n",
                        "O^O/ \\_/ \\    Batch size per device = 2 | Gradient accumulation steps = 1\n",
                        "\\        /    Data Parallel GPUs = 1 | Total batch size (2 x 1 x 1) = 2\n",
                        " \"-____-\"     Trainable parameters = 14,966,784/3,000,000,000 (0.50% trained)\n",
                        "train: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:10<00:00,  1.16it/s, loss=0.144, grad_norm=2.54, policy_loss=0.144]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Deleted checkpoint ./.art/codenames-rl/models/codenames_model_op_3/0000\n",
                        "✓ finished iter 0\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "iter 1: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [00:26<00:00,  2.64s/it]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Packed 200 trajectories into 9 sequences of length 2048\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "train: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 9/9 [00:05<00:00,  1.66it/s, loss=3.15, grad_norm=26.3, policy_loss=3.15]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Deleted checkpoint ./.art/codenames-rl/models/codenames_model_op_3/0001\n",
                        "✓ finished iter 1\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "iter 2: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [00:27<00:00,  2.72s/it]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Packed 80 trajectories into 3 sequences of length 2048\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "train: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:03<00:00,  1.23s/it, loss=12.6, grad_norm=599, policy_loss=12.6]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Deleted checkpoint ./.art/codenames-rl/models/codenames_model_op_3/0002\n",
                        "✓ finished iter 2\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "iter 3: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [00:28<00:00,  2.85s/it]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Packed 320 trajectories into 14 sequences of length 2048\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "train: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 14/14 [00:07<00:00,  1.90it/s, loss=0.937, grad_norm=38.8, policy_loss=0.937]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Deleted checkpoint ./.art/codenames-rl/models/codenames_model_op_3/0003\n",
                        "✓ finished iter 3\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "iter 4: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [00:28<00:00,  2.87s/it]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Packed 200 trajectories into 16 sequences of length 2048\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "train: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 16/16 [00:08<00:00,  1.98it/s, loss=0.236, grad_norm=0.739, policy_loss=0.236]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Deleted checkpoint ./.art/codenames-rl/models/codenames_model_op_3/0004\n",
                        "✓ finished iter 4\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "iter 5: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [00:28<00:00,  2.85s/it]\n",
                        "Running validation games: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 50/50 [00:13<00:00,  3.76it/s]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Packed 80 trajectories into 6 sequences of length 2048\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "train: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:04<00:00,  1.37it/s, loss=-0.706, grad_norm=1.36, policy_loss=-0.706]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Deleted checkpoint ./.art/codenames-rl/models/codenames_model_op_3/0005\n",
                        "✓ finished iter 5\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "iter 6: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [00:29<00:00,  2.95s/it]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Packed 240 trajectories into 8 sequences of length 2048\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "train: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 8/8 [00:05<00:00,  1.40it/s, loss=1.03, grad_norm=2.15, policy_loss=1.03]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Deleted checkpoint ./.art/codenames-rl/models/codenames_model_op_3/0006\n",
                        "✓ finished iter 6\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "iter 7: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [00:31<00:00,  3.18s/it]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Packed 320 trajectories into 16 sequences of length 2048\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "train: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 16/16 [00:09<00:00,  1.75it/s, loss=-0.35, grad_norm=1.23, policy_loss=-0.35]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Deleted checkpoint ./.art/codenames-rl/models/codenames_model_op_3/0007\n",
                        "✓ finished iter 7\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "iter 8: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [00:29<00:00,  2.97s/it]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Packed 80 trajectories into 2 sequences of length 2048\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "train: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2/2 [00:03<00:00,  1.54s/it, loss=1.3, grad_norm=19, policy_loss=1.3]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Deleted checkpoint ./.art/codenames-rl/models/codenames_model_op_3/0008\n",
                        "✓ finished iter 8\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "iter 9: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [00:30<00:00,  3.07s/it]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Packed 320 trajectories into 11 sequences of length 2048\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "train: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 11/11 [00:06<00:00,  1.61it/s, loss=-1.45, grad_norm=1.98, policy_loss=-1.45]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Deleted checkpoint ./.art/codenames-rl/models/codenames_model_op_3/0009\n",
                        "✓ finished iter 9\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "iter 10:   0%|                                                                                                                                                                         | 0/10 [00:00<?, ?it/s]"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Deleted checkpoint ./.art/codenames-rl/models/codenames_model_op_3/0137\n",
                        "✓ finished iter 137\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "iter 138: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [02:57<00:00, 17.80s/it]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Packed 560 trajectories into 199 sequences of length 6144\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "train: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 199/199 [02:14<00:00,  1.48it/s, loss=0.279, grad_norm=0.281, policy_loss=0.279]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Deleted checkpoint ./.art/codenames-rl/models/codenames_model_op_3/0138\n",
                        "✓ finished iter 138\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "iter 139: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [02:03<00:00, 12.31s/it]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Packed 640 trajectories into 228 sequences of length 6144\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "train: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████| 228/228 [02:33<00:00,  1.49it/s, loss=-0.0443, grad_norm=0.000549, policy_loss=-0.0443]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Deleted checkpoint ./.art/codenames-rl/models/codenames_model_op_3/0139\n",
                        "✓ finished iter 139\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "iter 140: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [03:32<00:00, 21.24s/it]\n",
                        "Running validation games: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 50/50 [00:34<00:00,  1.45it/s]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Packed 640 trajectories into 329 sequences of length 6144\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "train: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████| 329/329 [03:40<00:00,  1.49it/s, loss=-0.186, grad_norm=0.000985, policy_loss=-0.186]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Deleted checkpoint ./.art/codenames-rl/models/codenames_model_op_3/0140\n",
                        "✓ finished iter 140\n"
                    ]
                }
            ],
            "source": [
                "# ───────────────────────────  8. Training loop  ───────────────────────────\n",
                "for step in range(await model.get_step(), NUM_STEPS):\n",
                "    # Our model under training plays against itself and learns from the rewards for each trajectory\n",
                "    nested_groups = await tqdm_asyncio.gather(\n",
                "        *[\n",
                "            conduct_games(\n",
                "                blue_model=model,\n",
                "                red_model=model,\n",
                "                num_rollouts_per_game=NUM_ROLLOUTS_PER_GAME,\n",
                "                game_id=gid,\n",
                "                step=step,\n",
                "            )\n",
                "            for gid in range(NUM_GAMES_PER_STEP)\n",
                "        ],\n",
                "        total=NUM_GAMES_PER_STEP,\n",
                "        desc=f\"step {step}\",\n",
                "    )\n",
                "\n",
                "    if step % 5 == 0:\n",
                "        # We run validation games to evaluate the performance of our model against the benchmark model. Here, the reward is 1 if our model wins, and 0 otherwise.\n",
                "        val_groups = await run_validation_games(\n",
                "            my_model=model,\n",
                "            benchmark_model=benchmark_model,\n",
                "            num_validation_games=NUM_VALIDATION_GAMES,\n",
                "        )\n",
                "        await model.log(val_groups)\n",
                "\n",
                "    flat_groups: List[art.TrajectoryGroup] = [g for sub in nested_groups for g in sub]\n",
                "    await model.train(\n",
                "        trajectory_groups=flat_groups,\n",
                "        config=art.TrainConfig(learning_rate=LEARNING_RATE, beta=BETA),\n",
                "    )\n",
                "    await model.delete_checkpoints()\n",
                "    print(f\"✓ finished step {step}\")"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "id": "vGh6yN4Jjplb",
                "outputId": "d2cbc6b6-a63b-4f10-fadb-904d3bdbb3a3"
            },
            "outputs": [
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "2025-05-06 19:52:19,260\tINFO util.py:154 -- Missing packages: ['ipywidgets']. Run `pip install -U ipywidgets`, then restart the notebook server for rich notebook output.\n",
                        "Running validation games: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 50/50 [00:28<00:00,  1.74it/s]\n"
                    ]
                }
            ],
            "source": [
                "# ───────────────────────────  9. Benchmark model  ───────────────────────────\n",
                "# We will benchmark our model by comparing the win rates against the benchmark model with that of gpt-4.1-nano and gpt-4.1-mini.\n",
                "gpt_41_nano = art.Model(\n",
                "    name=\"gpt-4.1-nano\",\n",
                "    project=\"codenames-rl\",\n",
                "    inference_model_name=\"gpt-4.1-nano\",\n",
                "    inference_api_key=os.getenv(\"OPENAI_API_KEY\"),\n",
                "    inference_base_url=\"https://api.openai.com/v1\",\n",
                ")\n",
                "gpt_41_mini = art.Model(\n",
                "    name=\"gpt-4.1-mini\",\n",
                "    project=\"codenames-rl\",\n",
                "    inference_model_name=\"gpt-4.1-mini\",\n",
                "    inference_api_key=os.getenv(\"OPENAI_API_KEY\"),\n",
                "    inference_base_url=\"https://api.openai.com/v1\",\n",
                ")\n",
                "\n",
                "gpt_models = [gpt_41_nano, gpt_41_mini]\n",
                "\n",
                "for gpt_model in gpt_models:\n",
                "    await gpt_model.register(backend)\n",
                "    val_groups = await run_validation_games(\n",
                "        my_model=gpt_model,\n",
                "        benchmark_model=benchmark_model,\n",
                "        num_validation_games=NUM_VALIDATION_GAMES,\n",
                "    )\n",
                "    await gpt_model.log(val_groups)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "id": "_NQIBAlajplb",
                "outputId": "a171f7fa-0690-495f-d3e8-269049fbb6dc"
            },
            "outputs": [],
            "source": [
                "# ───────────────────────────  10. Plotting Utilities  ───────────────────────────\n",
                "import os\n",
                "\n",
                "from art.utils.benchmarking.load_trajectories import load_trajectories\n",
                "from art.utils.benchmarking.charts import training_progress_chart\n",
                "from art.utils.benchmarking.types import BenchmarkModelKey\n",
                "\n",
                "df = await load_trajectories(\n",
                "    project_name=\"codenames-rl\",\n",
                "    models=[MODEL_NAME, \"gpt-4.1-nano\", \"gpt-4.1-mini\"],\n",
                "    art_path=\"./.art\",\n",
                ")"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "id": "eFWWjkY5jplb",
                "outputId": "253504e3-38db-40ba-88a2-cf910d3255da"
            },
            "outputs": [
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 1800x1200 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "# ───────────────────────────  11. Plotting Win Rate over Time  ───────────────────────────\n",
                "line_graph = training_progress_chart(\n",
                "    df,\n",
                "    \"win_rate\",\n",
                "    models=[\n",
                "        BenchmarkModelKey(MODEL_NAME, MODEL_NAME, \"val\"),\n",
                "        BenchmarkModelKey(\"gpt-4.1-nano\", \"GPT-4.1-nano\", \"val\"),\n",
                "        BenchmarkModelKey(\"gpt-4.1-mini\", \"GPT-4.1-mini\", \"val\"),\n",
                "    ],\n",
                "    title=\"Win Rate over Time\",\n",
                "    y_label=\"Win Rate\",\n",
                ")\n",
                "\n",
                "line_graph.savefig(\"win_rate_over_time.png\")"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "id": "I7fdMxpKjakE"
            },
            "source": [
                "<div class=\"align-center\">\n",
                "<a href=\"https://github.com/openpipe/art\"><img src=\"https://github.com/openpipe/art/raw/notebooks/assets/ART_pill.png\" height=\"50\"></a>\n",
                "<a href=\"https://discord.com/invite/dnseNZuQ\"><img src=\"https://github.com/openpipe/art/raw/notebooks/assets/Discord_pill.png\" height=\"50\"></a>\n",
                "<a href=\"https://openpipe.ai/blog/art-e-mail-agent\"><img src=\"https://github.com/openpipe/art/raw/main/assets/ART_E_pill.png\" height=\"50\"></a>\n",
                "\n",
                "Questions? Join the Discord and ask away! For feature requests or to leave a star, visit our [GitHub](https://github.com/openpipe/art).\n",
                "\n",
                "</div>\n"
            ]
        }
    ],
    "metadata": {
        "accelerator": "GPU",
        "colab": {
            "gpuType": "T4",
            "provenance": []
        },
        "kernelspec": {
            "display_name": "Python 3",
            "name": "python3"
        },
        "language_info": {
            "name": "python"
        }
    },
    "nbformat": 4,
    "nbformat_minor": 0
}
